package com.everyline.baselibrary.utils;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.util.Log;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 文件描述：
 * 作者：G
 * 创建时间：2019/7/31
 */
public class JUtils {


    /**
     * @prama: str 要判断是否包含特殊字符的目标字符串
     */
    public static boolean compileExChar(String str) {
        String limitEx = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";

        Pattern pattern = Pattern.compile(limitEx);

        Matcher m = pattern.matcher(str);
        if (m.find()) {
            return false;
        }
        return true;
    }

    /**
     * 获取字符串的长度，如果有中文，则每个中文字符计为2位
     *
     * @param value 指定的字符串
     * @return 字符串的长度
     */
    public static int length(String value) {
        int valueLength = 0;
        String chinese = "[\u0391-\uFFE5]";
        /* 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1 */
        for (int i = 0; i < value.length(); i++) {
            /* 获取一个字符 */
            String temp = value.substring(i, i + 1);
            /* 判断是否为中文字符 */
            if (temp.matches(chinese)) {
                /* 中文字符长度为2 */
                valueLength += 2;
            } else {
                /* 其他字符长度为1 */
                valueLength += 1;
            }
        }
        return valueLength;
    }

    //获取距离当前时间 有多长
    public static String getStandardDate(String timeStr) {

        StringBuffer sb = new StringBuffer();

        long t = Long.parseLong(timeStr);
        long time = System.currentTimeMillis() - (t * 1000);
        long mill = (long) Math.floor(time / 1000);//秒前

        long minute = (long) Math.floor(time / 60 / 1000.0f);// 分钟前

        long hour = (long) Math.floor(time / 60 / 60 / 1000.0f);// 小时

        long day = (long) Math.floor(time / 24 / 60 / 60 / 1000.0f);// 天前

        if (day - 1 > 0) {
            sb.append(day + "天");
        } else if (hour - 1 > 0) {
            if (hour >= 24) {
                sb.append("1天");
            } else {
                sb.append(hour + "小时");
            }
        } else if (minute - 1 > 0) {
            if (minute >= 60) {
                sb.append("1小时");
            } else {
                sb.append(minute + "分钟");
            }
        } else if (mill - 1 > 0) {
            if (mill >= 60) {
                sb.append("1分钟");
            } else {
                sb.append(mill + "秒");
            }
        } else {
            sb.append("刚刚");
        }
        if (!sb.toString().equals("刚刚")) {
            sb.append("前");
        }
        return sb.toString();
    }

    /**
     * 版本号比较
     *
     * @param version1
     * @param version2
     * @return 0代表相等，1代表version1大于version2，-1代表version1小于version2
     */
    public static int compareVersion(String version1, String version2) {
        if (version1.equals(version2)) {
            return 0;
        }
        String[] version1Array = version1.split("\\.");
        String[] version2Array = version2.split("\\.");
        Log.d("version1Array==", "version1Array==" + version1Array.length);
        Log.d("version2Array==", "version2Array==" + version2Array.length);
        int index = 0;
        // 获取最小长度值
        int minLen = Math.min(version1Array.length, version2Array.length);
        int diff = 0;
        // 循环判断每位的大小

        while (index < minLen && (diff = Integer.parseInt(version1Array[index]) - Integer.parseInt(version2Array[index])) == 0) {
            index++;
        }
        Log.d("version====", "minlen===" + minLen + "diff====" + diff + "index====" + index);
        if (diff == 0) {
            // 如果位数不一致，比较多余位数
            for (int i = index; i < version1Array.length; i++) {
                if (Integer.parseInt(version1Array[i]) > 0) {
                    return 1;
                }
            }

            for (int i = index; i < version2Array.length; i++) {
                if (Integer.parseInt(version2Array[i]) > 0) {
                    return -1;
                }
            }
            return 0;
        } else {
            return diff > 0 ? 1 : -1;
        }
    }

    /**
     * 银行卡号，保留最后4位，其他星号替换
     *
     * @param cardId 卡号
     * @return 星号替换的银行卡号
     */
    public static String cardIdHide19(String cardId) {
        return cardId.replaceAll(" ", "").replaceAll("(\\d{4})\\d{11}(\\d{4})", "$1 **** **** *** $2");
    }

    public static String cardIdHide16(String cardId) {
        return cardId.replaceAll(" ", "").replaceAll("(\\d{4})\\d{8}(\\d{4})", "$1 **** ****  $2");
    }

    public static String cardIdHide17(String cardId) {
        return cardId.replaceAll(" ", "").replaceAll("(\\d{4})\\d{9}(\\d{4})", "$1 **** **** * $2");
    }

    /**
     * 身份证号，中间10位星号替换
     *
     * @param id 身份证号
     * @return 星号替换的身份证号
     */
    public static String idHide(String id) {
        return id.replaceAll("(\\d{4})\\d{10}(\\d{4})", "$1** **** ****$2");
    }

    /**
     * 手机号码，中间4位星号替换
     *
     * @param phone 手机号
     * @return 星号替换的手机号
     */
    public static String phoneNoHide(String phone) {
        // 括号表示组，被替换的部分$n表示第n组的内容
        // 正则表达式中，替换字符串，括号的意思是分组，在replace()方法中，
        // 参数二中可以使用$n(n为数字)来依次引用模式串中用括号定义的字串。
        // "(\d{3})\d{4}(\d{4})", "$1****$2"的这个意思就是用括号，
        // 分为(前3个数字)中间4个数字(最后4个数字)替换为(第一组数值，保持不变$1)(中间为*)(第二组数值，保持不变$2)
        return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }

    /**
     * 四舍五入 保留2位小数
     *
     * @param d
     * @return
     */
    public static String formatDouble(Double d) {
        DecimalFormat df = new DecimalFormat("0.##");
        return df.format(d);
    }
    public static String formatDouble1(float d) {
        DecimalFormat df = new DecimalFormat("0.#");
        return df.format(d);
    }

    //截取整数部分
    public static String formatInteger(Double d) {
        DecimalFormat df = new DecimalFormat("#");
        return df.format(d);
    }

    /**
     * 验证手机号码格式  ^1[0-9]{10}(\\-[0-9]){0,1}$
     *
     * @return
     */
    public static boolean isMobileNumber(String mobileNumber) {
        Pattern p = Pattern.compile("^1[0-9]{10}(\\-[0-9]){0,1}$");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    public static void onInactive(Context context, EditText et) {

        if (et == null)
            return;

        et.clearFocus();
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(et.getWindowToken(), 0);
    }

    /**
     * double 相加
     *
     * @param d1
     * @param d2
     * @return
     */
    public static double sum(double d1, double d2) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.add(bd2).doubleValue();
    }


    /**
     * double 相减
     *
     * @param d1
     * @param d2
     * @return
     */
    public static double sub(double d1, double d2) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.subtract(bd2).doubleValue();
    }

    /**
     * double 乘法
     *
     * @param d1
     * @param d2
     * @return
     */
    public static double mul(double d1, double d2) {
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.multiply(bd2).doubleValue();
    }


    /**
     * double 除法
     *
     * @param d1
     * @param d2
     * @param scale 四舍五入 小数点位数
     * @return
     */
    public static double div(float d1, float d2, int scale) {
        //  当然在此之前，你要判断分母是否为0，
        //  为0你可以根据实际需求做相应的处理
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        return bd1.divide(bd2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }


    /**
     * 检测是否安装支付宝
     *
     * @param context
     * @return
     */
    public static boolean checkAliPayInstalled(Context context) {

        Uri uri = Uri.parse("alipays://platformapi/startApp");
        Intent intent = new Intent(Intent.ACTION_VIEW, uri);
        ComponentName componentName = intent.resolveActivity(context.getPackageManager());
        return componentName != null;
    }

    /**
     * 用户名校验，4到16位（字母，数字，下划线，减号）  /^[a-zA-Z0-9_-]{4,16}$/
     *
     * @return
     */
    public static boolean isMobileNumber1(String mobileNumber) {
        Pattern p = Pattern.compile("/^[a-zA-Z0-9_-]{4,16}$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     * 密码强度校验，最少6位，包括至少1个大写字母，1个小写字母，1个数字，1个特殊字符  /^\S(?=\S{6,})(?=\S\d)(?=\S[A-Z])(?=\S[a-z])(?=\S[!@#$%^&? ])\S*$/
     *
     * @return
     */
    public static boolean isMobileNumber2(String mobileNumber) {
        Pattern p = Pattern.compile("/^\\S(?=\\S{6,})(?=\\S\\d)(?=\\S[A-Z])(?=\\S[a-z])(?=\\S[!@#$%^&? ])\\S*$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     * 身份证号(2代,18位数字),最后一位是校验位,可能为数字或字符X  /^[1-9]\d{5}(?:18|19|20)\d{2}(?:0[1-9]|10|11|12)(?:0[1-9]|[1-2]\d|30|31)\d{3}[\dXx]$/
     *
     * @return
     */
    public static boolean isMobileNumber3(String mobileNumber) {
        Pattern p = Pattern.compile("/^[1-9]\\d{5}(?:18|19|20)\\d{2}(?:0[1-9]|10|11|12)(?:0[1-9]|[1-2]\\d|30|31)\\d{3}[\\dXx]$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     * 座机(tel phone)电话(国内),如: 0341-86091234  /^\d{3}-\d{8}$|^\d{4}-\d{7,8}$/
     *
     * @return
     */
    public static boolean isMobileNumber4(String mobileNumber) {
        Pattern p = Pattern.compile("/^\\d{3}-\\d{8}$|^\\d{4}-\\d{7,8}$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     * date(日期)  /^\d{4}(-)(1[0-2]|0?\d)\1([0-2]\d|\d|30|31)$/
     *
     * @return
     */
    public static boolean isMobileNumber5(String mobileNumber) {
        Pattern p = Pattern.compile("/^\\d{4}(-)(1[0-2]|0?\\d)\\1([0-2]\\d|\\d|30|31)$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     * 车牌号(新能源) /[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领 A-Z]{1}[A-HJ-NP-Z]{1}(([0-9]{5}[DF])|([DF][A-HJ-NP-Z0-9][0-9]{4}))$/
     *
     * @return
     */
    public static boolean isMobileNumber6(String mobileNumber) {
        Pattern p = Pattern.compile("/[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领 A-Z]{1}[A-HJ-NP-Z]{1}(([0-9]{5}[DF])|([DF][A-HJ-NP-Z0-9][0-9]{4}))$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     * 车牌号(非新能源)  /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领 A-Z]{1}[A-HJ-NP-Z]{1}[A-Z0-9]{4}[A-Z0-9挂学警港澳]{1}$/
     *
     * @return
     */
    public static boolean isMobileNumber7(String mobileNumber) {
        Pattern p = Pattern.compile("/^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领 A-Z]{1}[A-HJ-NP-Z]{1}[A-Z0-9]{4}[A-Z0-9挂学警港澳]{1}$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     *车牌号(新能源+非新能源)  /^(?:[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领 A-Z]{1}[A-HJ-NP-Z]{1}(?:(?:[0-9]{5}[DF])|(?:DF[0-9]{4})))$|(?:[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领 A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9 挂学警港澳]{1})$/
     *
     * @return
     */
    public static boolean isMobileNumber8(String mobileNumber) {
        Pattern p = Pattern.compile("/^(?:[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领 A-Z]{1}[A-HJ-NP-Z]{1}(?:(?:[0-9]{5}[DF])|(?:DF[0-9]{4})))$|(?:[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领 A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9 挂学警港澳]{1})$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     * 银行卡号（10到30位, 覆盖对公/私账户, 参考微信支付）   /^[1-9]\d{9,29}$/
     *
     * @return
     */
    public static boolean isMobileNumber9(String mobileNumber) {
        Pattern p = Pattern.compile("/^[1-9]\\d{9,29}$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     *数字/货币金额（支持负数、千分位分隔符） /^-?\d+(,\d{3})*(\.\d{1,2})?$/
     *
     * @return
     */
    public static boolean isMobileNumber10(String mobileNumber) {
        Pattern p = Pattern.compile("/^-?\\d+(,\\d{3})*(\\.\\d{1,2})?$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     *大于等于0, 小于等于150, 支持小数位出现5, 如145.5, 用于判断考卷分数  /^150$|^(?:\d|[1-9]\d|1[0-4]\d)(?:.5)?$/
     *
     * @return
     */
    public static boolean isMobileNumber11(String mobileNumber) {
        Pattern p = Pattern.compile("/^150$|^(?:\\d|[1-9]\\d|1[0-4]\\d)(?:.5)?$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

    /**
     *统一社会信用代码  /^[0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/
     *
     * @return
     */
    public static boolean isMobileNumber12(String mobileNumber) {
        Pattern p = Pattern.compile("/^[0-9A-HJ-NPQRTUWXY]{2}\\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/");
        Matcher m = p.matcher(mobileNumber);
        return m.matches();
    }

}
